﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class GameplayPVEPveGlobalVluesWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(Gameplay.PVE.PveGlobalVlues);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 73, 73);
			
			
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "selfMoveType", _g_get_selfMoveType);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "selfAutoBack", _g_get_selfAutoBack);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsSingleEnemy", _g_get_IsSingleEnemy);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fps", _g_get_fps);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeScaleFactor", _g_get_timeScaleFactor);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ShowBattleUnitLog", _g_get_ShowBattleUnitLog);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DisableAStar", _g_get_DisableAStar);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LevelId", _g_get_LevelId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HudHeight", _g_get_HudHeight);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HudScaleX", _g_get_HudScaleX);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HudScaleY", _g_get_HudScaleY);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "moneyCount", _g_get_moneyCount);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "moneyCountRegion", _g_get_moneyCountRegion);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hitEffectRate", _g_get_hitEffectRate);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deadEffect", _g_get_deadEffect);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ShowWaveHitArea", _g_get_ShowWaveHitArea);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "shakeInterval", _g_get_shakeInterval);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "shakeRange", _g_get_shakeRange);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "shakeTime", _g_get_shakeTime);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerNormalAttackCauseHit", _g_get_PlayerNormalAttackCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerSkillCauseHit", _g_get_PlayerSkillCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerCriticalCauseHit", _g_get_PlayerCriticalCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerCriticalShake", _g_get_PlayerCriticalShake);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hitElementId", _g_get_hitElementId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "criticalRigidBreakRatio", _g_get_criticalRigidBreakRatio);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "criticalDamageRatio", _g_get_criticalDamageRatio);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "specificEnemy", _g_get_specificEnemy);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "enemyUseAttackPoint", _g_get_enemyUseAttackPoint);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ignoreRigidBreak", _g_get_ignoreRigidBreak);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ShowAstarPath", _g_get_ShowAstarPath);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsTestBattle", _g_get_IsTestBattle);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "RpgFightUseTextureBg", _g_get_RpgFightUseTextureBg);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsDeckBeforeRpg", _g_get_IsDeckBeforeRpg);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "TrackBulletType", _g_get_TrackBulletType);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HitAndRun", _g_get_HitAndRun);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "InitTeamEnergy", _g_get_InitTeamEnergy);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "TeamEnergyRecoverSpeed", _g_get_TeamEnergyRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "EnemyEnergyRecoverSpeed", _g_get_EnemyEnergyRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MpAutoRecoverSpeed", _g_get_MpAutoRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ModelShadowEditor", _g_get_ModelShadowEditor);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BulletSound", _g_get_BulletSound);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ZombieFindPathTest", _g_get_ZombieFindPathTest);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SelfRigidRatio", _g_get_SelfRigidRatio);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "EnemyRigidRatio", _g_get_EnemyRigidRatio);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SelfMeleeLine", _g_get_SelfMeleeLine);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SelfMeleeLine2", _g_get_SelfMeleeLine2);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsAuto", _g_get_IsAuto);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SelfRunIntoBattle", _g_get_SelfRunIntoBattle);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "EnemyRunIntoBattle", _g_get_EnemyRunIntoBattle);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ResetEffectRenderQueue", _g_get_ResetEffectRenderQueue);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "rpgLevelTime", _g_get_rpgLevelTime);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UseHeroMp", _g_get_UseHeroMp);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "AttackMpBase", _g_get_AttackMpBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HitMpBase", _g_get_HitMpBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KillMpBase", _g_get_KillMpBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KillEliteBase", _g_get_KillEliteBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KillBossBase", _g_get_KillBossBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MpMax", _g_get_MpMax);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MpInit", _g_get_MpInit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "JobAttackMpBonus", _g_get_JobAttackMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "JobHitMpBonus", _g_get_JobHitMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "JobMpInit", _g_get_JobMpInit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "JobAllyMpBonus", _g_get_JobAllyMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "JobMpCost", _g_get_JobMpCost);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BossScale", _g_get_BossScale);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultSkillCameraName", _g_get_defaultSkillCameraName);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "EnableSkillCamera", _g_get_EnableSkillCamera);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "RpgSceneId", _g_get_RpgSceneId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PreloadRpgScene", _g_get_PreloadRpgScene);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PreloadRpgBattleHeros", _g_get_PreloadRpgBattleHeros);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "AirDroneModelId", _g_get_AirDroneModelId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "HelicopterModelId", _g_get_HelicopterModelId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "TestShowArea", _g_get_TestShowArea);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "selfMoveType", _s_set_selfMoveType);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "selfAutoBack", _s_set_selfAutoBack);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsSingleEnemy", _s_set_IsSingleEnemy);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fps", _s_set_fps);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "timeScaleFactor", _s_set_timeScaleFactor);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ShowBattleUnitLog", _s_set_ShowBattleUnitLog);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DisableAStar", _s_set_DisableAStar);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LevelId", _s_set_LevelId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HudHeight", _s_set_HudHeight);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HudScaleX", _s_set_HudScaleX);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HudScaleY", _s_set_HudScaleY);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "moneyCount", _s_set_moneyCount);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "moneyCountRegion", _s_set_moneyCountRegion);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "hitEffectRate", _s_set_hitEffectRate);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "deadEffect", _s_set_deadEffect);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ShowWaveHitArea", _s_set_ShowWaveHitArea);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "shakeInterval", _s_set_shakeInterval);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "shakeRange", _s_set_shakeRange);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "shakeTime", _s_set_shakeTime);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerNormalAttackCauseHit", _s_set_PlayerNormalAttackCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerSkillCauseHit", _s_set_PlayerSkillCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerCriticalCauseHit", _s_set_PlayerCriticalCauseHit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerCriticalShake", _s_set_PlayerCriticalShake);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "hitElementId", _s_set_hitElementId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "criticalRigidBreakRatio", _s_set_criticalRigidBreakRatio);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "criticalDamageRatio", _s_set_criticalDamageRatio);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "specificEnemy", _s_set_specificEnemy);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "enemyUseAttackPoint", _s_set_enemyUseAttackPoint);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ignoreRigidBreak", _s_set_ignoreRigidBreak);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ShowAstarPath", _s_set_ShowAstarPath);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsTestBattle", _s_set_IsTestBattle);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "RpgFightUseTextureBg", _s_set_RpgFightUseTextureBg);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsDeckBeforeRpg", _s_set_IsDeckBeforeRpg);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "TrackBulletType", _s_set_TrackBulletType);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HitAndRun", _s_set_HitAndRun);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "InitTeamEnergy", _s_set_InitTeamEnergy);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "TeamEnergyRecoverSpeed", _s_set_TeamEnergyRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "EnemyEnergyRecoverSpeed", _s_set_EnemyEnergyRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MpAutoRecoverSpeed", _s_set_MpAutoRecoverSpeed);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ModelShadowEditor", _s_set_ModelShadowEditor);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BulletSound", _s_set_BulletSound);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ZombieFindPathTest", _s_set_ZombieFindPathTest);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SelfRigidRatio", _s_set_SelfRigidRatio);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "EnemyRigidRatio", _s_set_EnemyRigidRatio);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SelfMeleeLine", _s_set_SelfMeleeLine);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SelfMeleeLine2", _s_set_SelfMeleeLine2);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsAuto", _s_set_IsAuto);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SelfRunIntoBattle", _s_set_SelfRunIntoBattle);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "EnemyRunIntoBattle", _s_set_EnemyRunIntoBattle);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ResetEffectRenderQueue", _s_set_ResetEffectRenderQueue);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "rpgLevelTime", _s_set_rpgLevelTime);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "UseHeroMp", _s_set_UseHeroMp);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "AttackMpBase", _s_set_AttackMpBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HitMpBase", _s_set_HitMpBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KillMpBase", _s_set_KillMpBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KillEliteBase", _s_set_KillEliteBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KillBossBase", _s_set_KillBossBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MpMax", _s_set_MpMax);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MpInit", _s_set_MpInit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "JobAttackMpBonus", _s_set_JobAttackMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "JobHitMpBonus", _s_set_JobHitMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "JobMpInit", _s_set_JobMpInit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "JobAllyMpBonus", _s_set_JobAllyMpBonus);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "JobMpCost", _s_set_JobMpCost);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BossScale", _s_set_BossScale);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultSkillCameraName", _s_set_defaultSkillCameraName);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "EnableSkillCamera", _s_set_EnableSkillCamera);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "RpgSceneId", _s_set_RpgSceneId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PreloadRpgScene", _s_set_PreloadRpgScene);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PreloadRpgBattleHeros", _s_set_PreloadRpgBattleHeros);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "AirDroneModelId", _s_set_AirDroneModelId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "HelicopterModelId", _s_set_HelicopterModelId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "TestShowArea", _s_set_TestShowArea);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new Gameplay.PVE.PveGlobalVlues();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveGlobalVlues constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new Gameplay.PVE.PveGlobalVlues();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveGlobalVlues constructor!");
            
        }

        
		
        
		
        
        
        
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selfMoveType(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.selfMoveType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selfAutoBack(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.selfAutoBack);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsSingleEnemy(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.IsSingleEnemy);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fps(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.fps);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_timeScaleFactor(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.timeScaleFactor);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ShowBattleUnitLog(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ShowBattleUnitLog);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DisableAStar(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.DisableAStar);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_LevelId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.LevelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HudHeight(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.HudHeight);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HudScaleX(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.HudScaleX);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HudScaleY(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.HudScaleY);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moneyCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.PveGlobalVlues.moneyCount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moneyCountRegion(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.PushUnityEngineVector2(L, Gameplay.PVE.PveGlobalVlues.moneyCountRegion);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hitEffectRate(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.hitEffectRate);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_deadEffect(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.PveGlobalVlues.deadEffect);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ShowWaveHitArea(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ShowWaveHitArea);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_shakeInterval(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.shakeInterval);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_shakeRange(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.shakeRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_shakeTime(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.shakeTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerNormalAttackCauseHit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PlayerNormalAttackCauseHit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerSkillCauseHit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PlayerSkillCauseHit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerCriticalCauseHit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PlayerCriticalCauseHit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerCriticalShake(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PlayerCriticalShake);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hitElementId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.hitElementId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_criticalRigidBreakRatio(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.criticalRigidBreakRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_criticalDamageRatio(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.criticalDamageRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_specificEnemy(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.specificEnemy);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_enemyUseAttackPoint(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.enemyUseAttackPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ignoreRigidBreak(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ignoreRigidBreak);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ShowAstarPath(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ShowAstarPath);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsTestBattle(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.IsTestBattle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RpgFightUseTextureBg(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.RpgFightUseTextureBg);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsDeckBeforeRpg(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.IsDeckBeforeRpg);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TrackBulletType(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.TrackBulletType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HitAndRun(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.HitAndRun);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_InitTeamEnergy(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.InitTeamEnergy);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TeamEnergyRecoverSpeed(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.TeamEnergyRecoverSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_EnemyEnergyRecoverSpeed(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.EnemyEnergyRecoverSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MpAutoRecoverSpeed(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.MpAutoRecoverSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ModelShadowEditor(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ModelShadowEditor);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_BulletSound(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.BulletSound);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ZombieFindPathTest(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ZombieFindPathTest);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SelfRigidRatio(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.SelfRigidRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_EnemyRigidRatio(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.EnemyRigidRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SelfMeleeLine(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.SelfMeleeLine);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SelfMeleeLine2(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.SelfMeleeLine2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsAuto(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.IsAuto);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SelfRunIntoBattle(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.SelfRunIntoBattle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_EnemyRunIntoBattle(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.EnemyRunIntoBattle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ResetEffectRenderQueue(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.ResetEffectRenderQueue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgLevelTime(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.rpgLevelTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_UseHeroMp(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.UseHeroMp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AttackMpBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.AttackMpBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HitMpBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.HitMpBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KillMpBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.KillMpBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KillEliteBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.KillEliteBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KillBossBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.KillBossBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MpMax(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.MpMax);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MpInit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.MpInit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_JobAttackMpBonus(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.JobAttackMpBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_JobHitMpBonus(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.JobHitMpBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_JobMpInit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.JobMpInit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_JobAllyMpBonus(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.JobAllyMpBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_JobMpCost(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.JobMpCost);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_BossScale(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.PveGlobalVlues.BossScale);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_defaultSkillCameraName(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, Gameplay.PVE.PveGlobalVlues.defaultSkillCameraName);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_EnableSkillCamera(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.EnableSkillCamera);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RpgSceneId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.RpgSceneId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PreloadRpgScene(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PreloadRpgScene);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PreloadRpgBattleHeros(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.PreloadRpgBattleHeros);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AirDroneModelId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.AirDroneModelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HelicopterModelId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveGlobalVlues.HelicopterModelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TestShowArea(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveGlobalVlues.TestShowArea);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selfMoveType(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.selfMoveType = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selfAutoBack(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.selfAutoBack = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsSingleEnemy(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.IsSingleEnemy = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_fps(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.fps = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_timeScaleFactor(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.timeScaleFactor = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ShowBattleUnitLog(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ShowBattleUnitLog = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DisableAStar(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.DisableAStar = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_LevelId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.LevelId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HudHeight(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HudHeight = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HudScaleX(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HudScaleX = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HudScaleY(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HudScaleY = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moneyCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Gameplay.PVE.PveGlobalVlues.moneyCount = (System.Collections.Generic.List<int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moneyCountRegion(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			UnityEngine.Vector2 gen_value;translator.Get(L, 1, out gen_value);
				Gameplay.PVE.PveGlobalVlues.moneyCountRegion = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hitEffectRate(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.hitEffectRate = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_deadEffect(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Gameplay.PVE.PveGlobalVlues.deadEffect = (System.Collections.Generic.List<float>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<float>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ShowWaveHitArea(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ShowWaveHitArea = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_shakeInterval(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.shakeInterval = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_shakeRange(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.shakeRange = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_shakeTime(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.shakeTime = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerNormalAttackCauseHit(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PlayerNormalAttackCauseHit = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerSkillCauseHit(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PlayerSkillCauseHit = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerCriticalCauseHit(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PlayerCriticalCauseHit = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerCriticalShake(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PlayerCriticalShake = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hitElementId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.hitElementId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_criticalRigidBreakRatio(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.criticalRigidBreakRatio = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_criticalDamageRatio(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.criticalDamageRatio = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_specificEnemy(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.specificEnemy = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_enemyUseAttackPoint(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.enemyUseAttackPoint = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ignoreRigidBreak(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ignoreRigidBreak = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ShowAstarPath(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ShowAstarPath = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsTestBattle(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.IsTestBattle = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_RpgFightUseTextureBg(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.RpgFightUseTextureBg = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsDeckBeforeRpg(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.IsDeckBeforeRpg = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TrackBulletType(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.TrackBulletType = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HitAndRun(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HitAndRun = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_InitTeamEnergy(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.InitTeamEnergy = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TeamEnergyRecoverSpeed(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.TeamEnergyRecoverSpeed = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_EnemyEnergyRecoverSpeed(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.EnemyEnergyRecoverSpeed = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MpAutoRecoverSpeed(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.MpAutoRecoverSpeed = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ModelShadowEditor(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ModelShadowEditor = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_BulletSound(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.BulletSound = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ZombieFindPathTest(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ZombieFindPathTest = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SelfRigidRatio(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.SelfRigidRatio = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_EnemyRigidRatio(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.EnemyRigidRatio = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SelfMeleeLine(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.SelfMeleeLine = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SelfMeleeLine2(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.SelfMeleeLine2 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsAuto(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.IsAuto = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SelfRunIntoBattle(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.SelfRunIntoBattle = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_EnemyRunIntoBattle(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.EnemyRunIntoBattle = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ResetEffectRenderQueue(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.ResetEffectRenderQueue = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgLevelTime(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.rpgLevelTime = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_UseHeroMp(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.UseHeroMp = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_AttackMpBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.AttackMpBase = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HitMpBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HitMpBase = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KillMpBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.KillMpBase = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KillEliteBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.KillEliteBase = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KillBossBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.KillBossBase = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MpMax(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.MpMax = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MpInit(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.MpInit = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_JobAttackMpBonus(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.JobAttackMpBonus = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_JobHitMpBonus(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.JobHitMpBonus = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_JobMpInit(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.JobMpInit = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_JobAllyMpBonus(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.JobAllyMpBonus = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_JobMpCost(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.JobMpCost = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_BossScale(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.BossScale = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_defaultSkillCameraName(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.defaultSkillCameraName = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_EnableSkillCamera(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.EnableSkillCamera = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_RpgSceneId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.RpgSceneId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PreloadRpgScene(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PreloadRpgScene = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PreloadRpgBattleHeros(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.PreloadRpgBattleHeros = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_AirDroneModelId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.AirDroneModelId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HelicopterModelId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.HelicopterModelId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TestShowArea(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveGlobalVlues.TestShowArea = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
